// 引入游戏实体类
// 确保在使用Wall类之前已经加载
if (typeof window !== 'undefined') {
    // 检查Wall类是否已加载，如果没有则等待加载完成
    if (!window.Wall) {
        console.warn('Wall class not loaded yet, waiting for it to load...');
    }
}

// 确保Wall类可用
const getWallClass = () => {
    // 如果Wall类直接可用，则返回它
    if (typeof Wall !== 'undefined') {
        return Wall;
    }
    // 如果Wall类在window对象上可用，则返回它
    if (typeof window !== 'undefined' && window.Wall) {
        return window.Wall;
    }
    // 如果Wall类不可用，则返回一个基本的墙壁类
    console.error('Wall class is not available, using fallback implementation');
    return class FallbackWall {
        constructor(id, x, y, width, height) {
            this.id = id;
            this.x = x;
            this.y = y;
            this.width = width;
            this.height = height;
            this.health = 3;
            this.maxHealth = 3;
            this.isEdgeWall = false;
        }
        
        render(ctx) {
            const offsetX = ctx.canvas.offsetX || 0;
            const offsetY = ctx.canvas.offsetY || 0;
            const alpha = this.isEdgeWall ? 1 : this.health / this.maxHealth;
            ctx.fillStyle = `rgba(128, 128, 128, ${alpha})`;
            ctx.fillRect(this.x + offsetX, this.y + offsetY, this.width, this.height);
        }
        
        takeDamage(damage) {
            if (this.isEdgeWall) return;
            this.health = Math.max(0, this.health - 1);
            return this.health <= 0;
        }
    };
}

// 游戏世界类
class World {
    constructor(mapWidth, mapHeight) {
        // 修改：确保地图宽度使用服务器配置的固定值，而不是画布宽度
        this.mapWidth = 1600; // 固定地图宽度为1600，与服务器端GAME_CONFIG.mapWidth一致
        this.mapHeight = 1200; // 固定地图高度为1200，与服务器端GAME_CONFIG.mapHeight一致
        this.tanks = {};
        this.bullets = {};
        this.walls = {};
        this.systems = [];
        this.events = {};
        this.localPlayerId = null;
        this.networkSystem = null;
        this.localInput = null;
    }

    // 初始化游戏世界
    init(socket, playerId) {
        this.localPlayerId = playerId;
        
        // 创建并初始化网络系统
        this.networkSystem = new NetworkSystem(this);
        this.networkSystem.init(socket);
        
        // 添加网络系统到系统列表
        this.addSystem(this.networkSystem);
    }

    // 添加系统
    addSystem(system) {
        this.systems.push(system);
        return this;
    }

    // 更新游戏世界
    update(deltaTime) {
        // 更新所有系统
        for (const system of this.systems) {
            system.update(deltaTime);
        }
    }
    
    // 获取坦克
    getTanks() {
        return this.tanks;
    }
    
    // 获取子弹
    getBullets() {
        return this.bullets;
    }
    
    // 获取墙壁
    getWalls() {
        return this.walls;
    }
    
    // 获取地图宽度
    getMapWidth() {
        return this.mapWidth;
    }
    
    // 获取地图高度
    getMapHeight() {
        return this.mapHeight;
    }
    
    // 添加坦克
    addTank(tank) {
        this.tanks[tank.id] = tank;
    }
    
    // 移除坦克
    removeTank(tankId) {
        delete this.tanks[tankId];
    }
    
    // 添加子弹
    addBullet(bullet) {
        this.bullets[bullet.id] = bullet;
    }
    
    // 移除子弹
    removeBullet(bulletId) {
        delete this.bullets[bulletId];
    }
    
    // 添加墙壁
    addWall(wall) {
        this.walls[wall.id] = wall;
    }
    
    // 事件系统 - 注册事件监听器
    on(eventName, callback) {
        if (!this.events[eventName]) {
            this.events[eventName] = [];
        }
        this.events[eventName].push(callback);
    }
    
    // 事件系统 - 触发事件
    emit(eventName, data) {
        const callbacks = this.events[eventName];
        if (callbacks) {
            callbacks.forEach(callback => callback(data));
        }
    }
    
    // 获取本地玩家的坦克
    getLocalTank() {
        if (!this.localPlayerId) return null;
        
        // 遍历所有坦克，找到属于本地玩家的坦克
        for (const tankId in this.tanks) {
            const tank = this.tanks[tankId];
            if (tank.playerId === this.localPlayerId) {
                return tank;
            }
        }
        
        return null; // 如果没有找到本地玩家的坦克，返回null
    }
    
    // 更新本地输入状态
    updateLocalInput(input) {
        this.localInput = input;
        
        // 注意：NetworkSystem没有sendInput方法，输入数据会在NetworkSystem的update方法中发送
        // 不需要在这里调用发送方法
    }
    
    // 更新游戏状态（从服务器接收）
    updateGameState(gameState) {
        // 更新坦克
        if (gameState.tanks) {
            // 清除不存在的坦克
            for (const tankId in this.tanks) {
                if (!gameState.tanks[tankId]) {
                    delete this.tanks[tankId];
                }
            }
            
            // 更新或添加坦克
            for (const tankId in gameState.tanks) {
                const serverTank = gameState.tanks[tankId];
                
                if (this.tanks[tankId]) {
                    // 更新现有坦克
                    Object.assign(this.tanks[tankId], serverTank);
                    // 确保active属性为true
                    this.tanks[tankId].active = true;
                } else {
                    // 创建新坦克 - 使用Tank类实例
                    const newTank = new Tank(
                        serverTank.id,
                        serverTank.playerId,
                        serverTank.x,
                        serverTank.y,
                        serverTank.width,
                        serverTank.height,
                        serverTank.direction,
                        serverTank.speed,
                        serverTank.health,
                        serverTank.color
                    );
                    this.addTank(newTank);
                }
            }
        }
        
        // 更新子弹
        if (gameState.bullets) {
            // 清除不存在的子弹
            for (const bulletId in this.bullets) {
                if (!gameState.bullets[bulletId]) {
                    delete this.bullets[bulletId];
                }
            }
            
            // 更新或添加子弹
            for (const bulletId in gameState.bullets) {
                const serverBullet = gameState.bullets[bulletId];
                
                if (this.bullets[bulletId]) {
                    // 更新现有子弹
                    Object.assign(this.bullets[bulletId], serverBullet);
                } else {
                    // 创建新子弹 - 修改这里，确保创建Bullet类实例
                    const newBullet = new Bullet(
                        serverBullet.id,
                        serverBullet.tankId,
                        serverBullet.playerId,
                        serverBullet.x,
                        serverBullet.y,
                        serverBullet.width,
                        serverBullet.height,
                        serverBullet.velocityX,
                        serverBullet.velocityY
                    );
                    this.addBullet(newBullet);
                }
            }
        }
        
        // 更新墙壁
        if (gameState.walls) {
            // 清除不存在的墙壁
            for (const wallId in this.walls) {
                if (!gameState.walls[wallId]) {
                    delete this.walls[wallId];
                }
            }
            
            // 更新或添加墙壁
            for (const wallId in gameState.walls) {
                const serverWall = gameState.walls[wallId];
                
                if (this.walls[wallId]) {
                    // 更新现有墙壁
                    Object.assign(this.walls[wallId], serverWall);
                } else {
                    // 创建新墙壁 - 确保创建Wall类实例
                    const WallClass = getWallClass();
                    const newWall = new WallClass(
                        serverWall.id,
                        serverWall.x,
                        serverWall.y,
                        serverWall.width,
                        serverWall.height
                    );
                    // 复制其他属性
                    if (serverWall.health !== undefined) newWall.health = serverWall.health;
                    if (serverWall.maxHealth !== undefined) newWall.maxHealth = serverWall.maxHealth;
                    if (serverWall.isEdgeWall !== undefined) newWall.isEdgeWall = serverWall.isEdgeWall;
                    
                    this.addWall(newWall);
                }
            }
        }
    }
}

// 如果在浏览器环境中，将World添加到window对象
if (typeof window !== 'undefined') {
    window.World = World;
}

// 如果在Node.js环境中，导出World类
if (typeof module !== 'undefined' && module.exports) {
    module.exports = World;
}